/*
 * @Author: fengxx
 * @Date: 2025-08-21 17:05:33
 * @LastEditors: fengxx
 * @LastEditTime: 2025-08-28 15:31:12
 */
/*
 * @Author: fengxx
 * @Date: 2025-08-21 10:32:50
 * @LastEditors: fengxx
 * @LastEditTime: 2025-08-25 17:44:57
 */

// let a1 = 'fddf'
// // a1 = 1;  // 报错，隐式设置类型
// let a: string = '123'
// let num: number = 123;//普通数字
// let booleand: boolean = true //可以直接使⽤布尔值
// let booleand2: boolean = Boolean(1) //也可以通过函数返回布尔值
// let createdBoolean: Boolean = new Boolean(1) // 实例化的类型必须是实例对象类型

// console.log(booleand2)

// let list: number[] = [1, 2, 3]; // 数组的每一项都必须是number类型
// let list1: Array<number> = [1, 2, 3];
// let list2: string[][] = [['1']]

// let data:number[][][] = [[[1,2], [3,4]]]; // 多维数组

// function Arr(...args:any): void {
//  console.log(arguments)
//  //错误的arguments 是类数组不能这样定义
//  let arr: IArguments = arguments // 类数组
// }
// Arr(111, 222, 333)

// interface NumberArray {
//  [index: number]: number;
// }
// //表示：只要索引的类型是数字时，那么值的类型必须是数字。
// let fibonacci: NumberArray = [1, 1, 2, 3, 5];
// let fibonacci1: NumberArray = {
//   0: 1
// }

// let x: [string, number]; // 元组：定义一个默认长度的数组，数组的每一个item的类型可以不一致
// x = ['1',2]

// let arr2: readonly [number,boolean,string,undefined] = [1,true,'sring',undefined] // 只读数据
// const arr3: [number,boolean,string,undefined] = [1,true,'sring',undefined]

// let arr:[number,string] = [1,'string']
// // arr[0].length //error
// arr[1].length //success

// let excel: [string, string, number, string][] = [
//  ['title', 'name', 1, '123'],
//  ['title', 'name', 1, '123'],
//  ['title', 'name', 1, '123'],
//  ['title', 'name', 1, '123'],
//  ['title', 'name', 1, '123'],
// ]

// function voidFn(): void {
//  console.log('test void')
//  return undefined  // 报错：函数返回值类型为void不可以加return
// }

// let u: void = undefined
// let n: void = null; // 报错

// let u1: undefined = undefined;//定义undefined
// let n1: null = null;//定义null
// let a: string | undefined = 'dsfdsg' // 多种类型
// a = u1

// function fun(a: number, b: number): string {
//   // return (a+b).toString()
//   return `${a+b}`
// }

//代表了有⼀个label属性且类型为string的对象
// interface LabelledValue {
//  label?: string;  // 可选属性
//  size: string
// }

// function printLabel(labelledObj: LabelledValue) {
//  console.log(labelledObj.label);
// }
// let myObj = {size: '10', label: "Size 10 Object"};
// printLabel(myObj);

// interface Point {
//  readonly x: number; // 只读
//  readonly y: number;
// }
// let p1: Point = { x: 10, y: 20 };
// p1.x = 5; // error!

// interface PP {
//   a: string,
//   b: number
// }

// interface Person {
//   readonly name: string, // 只读属性
//   age: number,
//   sex?: number,  // 可选属性
//   [propName: string]: any, // 额外属性
//   hobby: PP
// }

// let p: Person[] = [{
//   name: '张三',
//   age: 18,
//   hobby: {
//     a: 'dgg',
//     b: 1
//   }
// }]
// console.log(p.name, p.age)

// function fun(p: Person): string {
//   return `${p.name}${p.age}`
// }

// let obj: Person = { name: 'dfdf', age: 1, sex: 1, h: 1, g: 1 };
// console.log(fun(obj))

//允许添加新的任意属性
// interface Person {
//   b?: string;
//   a: string;
//   [propName: string]: any;
// }

// const person: Person = {
//  a:"213",
//  c:"123"
// }

// interface SearchFunc {
//  (source: string, subString: string): boolean;
// }
// //调⽤
// let mySearch: SearchFunc;
// mySearch = function(source1, subString1) {
//  let result = source1.search(subString1);
//  console.log(result)
//  return result > -1;
// }
// console.log(mySearch('hello world', 'hello'))

// interface Sum {
//   (a: number, b: number): string
// }
// let fun: Sum =  function(a, b) {
//   return `${a + b}`
// }
// console.log(fun(1,2))

// interface IFun1 {
//  (): void;
// }
// let fun111: IFun1 = function() {
//  return '22';
// }
// // let fun1111 = function() : void {
// //  return '22'; // 这⾥不会报错，虽然返回了字符串
// // }
// console.log(fun111()); // 打印 22

// interface StringArray {
//  readonly [index: number]: string;
// }
// let myArray: StringArray;
// myArray = ["Bob", "Fred"];
// // myArray[0] = 'sdfdsf'

// let obj = {
//   0: 'hh',
//   1: 'sdfdsf'
// }
// let myStr: string | undefined = myArray[0];
// console.log(myStr, obj[0])

// 重名interface 可以合并
// interface A {name: string}
// interface A {age: number}
// interface A {h: number}
// var x: A = {name: 'xx', age: 20, h: 1}
// console.log(x)

// function fun(arr: number[]): number {
//   let sum: number = 0
//   arr.forEach((item: number)=>{
//     sum += item;
//   })
//   return sum;
// }

// console.log(fun([1,2,3]))

// interface Sum{
//   (arr: number[]): number
// }

// let sum1:Sum = function(arr) {
//   let sum: number = 0
//   arr.forEach((item: number)=>{
//     sum += item;
//   })
//   return sum;
// }
// console.log(sum1([1,2,3]))

//继承
// interface A{
//  name:string
// }

// interface B extends A{
//  age:number
// }

// let obj:B = {
//  age:18,
//  name:"string"
// }

// console.log(obj)

// interface Shape {
//  color: string;
// }
// interface PenStroke {
//  penWidth: number;
// }
// // 继承多个接口用逗号隔开
// interface Square extends Shape, PenStroke {
//  sideLength: number;
//  [propName: string]: any
// }

// let p: Square = {
//   color: 'red',
//   penWidth: 2,
//   sideLength: 4
// }
// // console.log(p.penWidth)

// let square = <Square>{};
// square.color1 = 'red'
// console.log(square)

// interface People {
//   heads: number,
//   foots: number
// }
// interface Man extends People {
//   hair: string
// }

// interface Woman extends People {
//   cloth: string
// }
// interface Babby extends Man, Woman {
//   face: string
// }
// let man: Man = {
//    heads: 1,
//   foots: 2,
//   hair: 'short',
// }
// let woman: Woman  = {
//   heads: 1,
//   foots: 2,
//   cloth: 'follower'
// }
// let baby: Babby = {
//   heads: 1,
//   foots: 2,
//   hair: 'short',
//   face: 'white',
//   cloth: 'yellow'
// }

// console.log(man, woman, baby)

// 抽象类：不能实例化，只能被继承
// abstract class A {
//   // public a: string = "lllo";
//   // private name: string; // 只能在当前类里面使用
//   protected age: number = 0; // 可以在当前类或者他的子类使用
//   static hh: boolean = true;
//   readonly gg: number = 0; // 只读
//   // 定义并且赋值
//   constructor(private _name: string, public a: string, gg: number) {
//     this.gg = gg;
//   }
//   fun(ty: string): boolean {
//     console.log(this._name, this.age, this.a, this.gg);
//     return !!ty;
//   }

//   set name(value: string) {
//     this._name = value;
//   }

//   get name(): string {
//     return this._name;
//   }

//   // 抽象方法：只能定义类型，不能写函数体，必须子类实现
//   abstract fun2(): void;
// }

// class B extends A {
//   constructor() {
//     super("ddd", "uu", 2);
//     // console.log(this.age);
//   }
//   fun1() {
//     console.log(this.age);
//     super.fun("loloo");
//   }
//   // 重写必须和父类定义的方法结构一致
//   fun(ty: string): boolean {
//     console.log("重写");
//     return !ty;
//   }
//   set _age(value: number) {
//     this.age = value;
//   }
//   fun2(): void {}
// }

// let a = new A("kkkk", "llll", 2);
// a.name = "lplp";

// console.log(a.name, a.gg, A.hh);
// a.gg = 1;
// console.log(a.age)
// a.fun();

// let b = new B();
// // b._age = 18;
// console.log(b.fun(""));
// b.fun1();

// let a: A;
// a = new B();
// console.log(a.a);

// interface I {
//   aa: string;
//   bb?: number; // 可选
// }
// // 组合接口
// interface II extends I {
//   fun(tt: boolean): void;
// }
// // 类要实现所有接口的所有内容
// class AA implements II {
//   aa: string = "oooo";
//   bb = 9;
//   fun(tt: boolean) {
//     console.log(tt ? this.aa : "实例没有aa参数");
//   }
// }

// let aa: AA = new AA();
// aa.fun(false);

// class Animal {
//   name: string;
//   constructor(theName: string) {
//     this.name = theName;
//   }
//   move(distanceInMeters: number = 0) {
//     console.log(`${this.name} moved ${distanceInMeters}m.`);
//   }
// }
// class Snake extends Animal {
//   constructor(name: string) {
//     super(name);
//   }
//   move(distanceInMeters = 5) {
//     console.log("Slithering...");
//     super.move(distanceInMeters);
//   }
// }
// class Horse extends Animal {
//   constructor(name: string) {
//     super(name);
//   }
//   move(distanceInMeters = 45) {
//     console.log("Galloping...");
//     super.move(distanceInMeters);
//   }
// }
// let jim: Animal = new Animal("Jim");
// jim.move(90);
// let sam = new Snake("Sammy the Python");
// sam.move();
// let tom: Animal = new Horse("Tommy the Palomino");
// tom.move(34);

// class Person {
//   public name: string;
//   public hh: number = 9;
//   private age: number;
//   protected some: any;
//   static kk: string = "kkk";
//   readonly ll: string = "";
//   constructor(name: string, ages: number, some: any) {
//     this.name = name;
//     this.age = ages;
//     this.some = some;
//   }
//   run() {
//     console.log(Person.kk, this.age);
//   }

//   // 如果两个函数都是static 静态的是可以通过this互相调⽤
//   static aa() {
//     this.bb();
//     // Person.bb();
//   }
//   static bb() {
//     console.log(this.kk);
//   }
// }
// Person.aa();

// class Man extends Person {
//   constructor() {
//     super("张三", 18, 1);
//     console.log(this.some);
//   }
//   create() {
//     console.log(this.some);
//   }
// }
// let xiaoman = new Person("⼩满", 18, 1);
// let man = new Man();
// console.log(man.name);

// abstract class Department {
//   constructor(public name: string) {}
//   printName(): void {
//     console.log("Department name: " + this.name);
//   }
//   abstract printMeeting(): void; // 必须在派⽣类中实现
// }
// class AccountingDepartment extends Department {
//   constructor() {
//     super("Accounting and Auditing"); // 在派⽣类的构造函数中必须调⽤ super()
//   }
//   printMeeting(): void {
//     console.log("The Accounting Department meets each Monday at 10am.");
//   }
//   generateReports(): void {
//     console.log("Generating accounting reports...");
//   }
// }
// let department: Department; // 允许创建⼀个对抽象类型的引⽤
// // department = new Department(); // 错误: 不能创建⼀个抽象类的实例
// department = new AccountingDepartment(); // 允许对⼀个抽象⼦类进⾏实例化和赋值
// department.printName();
// department.printMeeting();
// department.generateReports(); // 错误: ⽅法在声明的抽象类中不存在

// interface PersonClass {
//   get(type: boolean): boolean;
// }

// interface PersonClass2 {
//   set(): void;
//   asd: string;
// }

// class A {
//   name: string;
//   constructor(name: string) {
//     this.name = name;
//   }
// }

// class Person extends A implements PersonClass, PersonClass2 {
//   asd: string;
//   constructor(name: string) {
//     super(name);
//     this.asd = "123";
//   }
//   get(type: boolean) {
//     return type;
//   }
//   set() {
//     this.name = this.asd;
//   }
// }

// let p = new Person("pp");
// p.set();
// console.log(p.get(3 > 5 && 9 > 8));

// function fun(str: string): string {
//   let newStr: string = "";
//   let arr: string[] = str.split(" ");
//   let newArr: string[] = arr.map((item: string) => {
//     return item.charAt(0).toLocaleUpperCase() + item.slice(1, item.length);
//   });
//   newStr = newArr.join(" ");
//   return newStr;
// }

// console.log(fun("hello, my name is may"));

// 函数申明
// function fun(a: string): number {
//   return 0;
// }

// let fun1 = function (a: string): void {};

// // 不是箭头函数
// let fun2: (a?: string) => string = function (a) {
//   return "";
// };
// // 箭头函数
// let fun3 = (a: boolean = false): boolean => !!a;
// let fun4: (a?: boolean) => boolean = (a) => a || false;

// let fun5 = function (...args: any[]) {
//   console.log(args);
// };

// // 可选参数一般放在必选参数的后面
// interface Fun {
//   (a: string, b: boolean, c?: number): boolean;
// }
// let fun6: Fun = function (a, b, c) {
//   return b;
// };

// fun2();
// console.log(fun3(8 < 9));
// fun4();
// fun5([1, 2]);
// fun6("", true, 0);

// let sum: (price: number, quantity: number) => number = function (
//   price,
//   quantity
// ) {
//   return price * quantity;
// };

// console.log(sum(3, 3));

// interface P {
//   price: number;
//   quantity: number;
// }

// let sum1: (p: P[]) => number = function (p) {
//   let totalPrice: number = 0;
//   p.forEach((item: P) => {
//     totalPrice += item.price * item.quantity;
//   });
//   return totalPrice;
// };

// let arr: P[] = [
//   {
//     price: 3,
//     quantity: 3,
//   },
//   {
//     price: 1,
//     quantity: 2,
//   },
// ];

// console.log(sum1(arr));

// // 函数重载
// function fn(params: number): void;

// function fn(params: string, params2: number): void;

// function fn(params: any, params2?: any): void {
//   console.log(params);

//   console.log(params2);
// }

// fn(123);

// fn("111", 111);

// // 重载签名
// function reverse(str: string): string;
// function reverse(arr: any[]): any[];
// // 实现签名
// function reverse(stringOrArray: string | any[]): string | any[] {
//   if (typeof stringOrArray === "string")
//     return stringOrArray.split("").reverse().join("");
//   else return stringOrArray.slice().reverse();
// }
// reverse("klil");
// reverse([1, 3, 2, 1]);

// function fun(str: string): string[];
// function fun(arr: any[]): string;
// function fun(a: string | any[]): string | string[] {
//   if (typeof a === "string") {
//     return a.split("");
//   } else {
//     return a.join("");
//   }
// }

// console.log(fun("1234"));
// console.log(fun([1, 2, 3]));

// 内置对象类型
// let b: Boolean = new Boolean(1);
// console.log(b);
// let n: Number = new Number(true);
// console.log(n);
// let s: String = new String("哔哩哔哩");
// console.log(s);
// let d: Date = new Date();
// console.log(d);
// let r: RegExp = /^1/;
// console.log(r);
// let e: Error = new Error("error!");
// console.log(e);

// let div: HTMLElement = document.getElementById("kk") as HTMLDivElement;
// let a: HTMLAnchorElement = document.querySelector("a") as HTMLAnchorElement;
// let attr: string = a.getAttribute("href") as string;
// div.innerHTML = "dfdg";

// 商品类
// class Product {
//   private _name: string;
//   private _price: number;
//   private _quantity: number;
//   constructor(name: string, price: number, quantity: number) {
//     this._name = name;
//     this._price = price;
//     this._quantity = quantity;
//   }

//   get name(): string {
//     return this._name;
//   }

//   set name(value: string) {
//     this._name = value;
//   }

//   get price(): number {
//     return this._price;
//   }

//   set price(value: number) {
//     this._price = value;
//   }

//   get quantity(): number {
//     return this._quantity;
//   }

//   set quantity(value: number) {
//     this._quantity = value;
//   }

//   private totalPrice(): number {
//     return this._price * this._quantity;
//   }

//   productInfo(): string {
//     return `商品：${this._name}, 单价：${this._price}, 数量：${
//       this._quantity
//     }，总价${this.totalPrice()}`;
//   }
// }

// 购物车类
// class ShoppingCart {
//   // 商品列表
//   private products: Product[];
//   // 所有购物车数量
//   static count: number = 0;
//   constructor(products: Product[]) {
//     this.products = products;
//     // 初始化时计算购物车所有的商品数量
//     ShoppingCart.count += products.reduce((a: number, b: Product) => {
//       return a + b.quantity;
//     }, 0);

//     // let sumCount: number = 0;
//     // this.products.forEach((item: Product) => {
//     //   const { quantity } = item;
//     //   sumCount += quantity;
//     // });
//     // ShoppingCart.count =  sumCount;
//   }
//   // 添加商品
//   addProducts(product: Product): void {
//     this.products.push(product);
//     // 新增时购物车总数加上新增的数量
//     ShoppingCart.count += product.quantity;
//   }
//   // 移除商品
//   delProduct(product: Product): void {
//     this.products = this.products.filter(
//       (item: Product) => item.name !== product.name
//     );
//     ShoppingCart.count -= product.quantity;
//   }
//   // 计算购物车总价
//   cartTotalPrice(): number {
//     // return this.products.reduce((a: number, b: Product) => {
//     //   return a + b.price * b.quantity;
//     // }, 0);

//     // [
//     //   {
//     //     name: '衣服',
//     //     price: 1,
//     //     quantity: 10
//     //   },
//     //   {
//     //     name: '衣服',
//     //     price: 1,
//     //     quantity: 10
//     //   }
//     // ]

//     let sumPrice: number = 0;
//     this.products.forEach((item: Product) => {
//       const { price, quantity } = item;
//       sumPrice += price * quantity;
//     });
//     return sumPrice;
//   }
//   // 返回购物车总数
//   static cartTotalQuantity(): number {
//     return this.count;
//   }

//   get _products(): Product[] {
//     return this.products;
//   }
//   set _products(value: Product[]) {
//     this.products = value;
//   }
// }

// let product1 = new Product("衣服", 100, 10);

// console.log(product1.productInfo());
// let cartProducts: Product[] = [];
// cartProducts.push(product1);
// let cart1 = new ShoppingCart(cartProducts);

// console.log(
//   `所有购物车的总数量为：${ShoppingCart.cartTotalQuantity()}，购物车总价为：${cart1.cartTotalPrice()}`
// );

// let product2: Product = new Product("鞋子", 201, 5);
// console.log(product2.productInfo());
// cart1.addProducts(product2);
// console.log(
//   `所有购物车的总数量为：${ShoppingCart.cartTotalQuantity()}，购物车总价为：${cart1.cartTotalPrice()}`
// );

// let cart2 = new ShoppingCart([product2]);
// console.log(`购物车的总数量为：${ShoppingCart.cartTotalQuantity()}`);

// 枚举类型：用来表示确定值的类型，只支持string和number类型
// 如果全不给默认值，则从0开始自增

// 常量枚举：用来减少内存空间
// enum Typ {
//   Red = "string",
//   Green = "fff",
//   Blue = "dgfdgf",
//   Yellow = "err",
// }

// let a1 = Typ.Yellow;
// // console.log(Typ[a1]);

// // 反向映射：number类型才支持
// // 常量枚举不支持反向映射
// const enum Enum {
//   fall = 0,
// }
// let a = Enum.fall;
// console.log(a); //0
// // let nameOfB = Enum[a]; // 错误， 常量枚举不支持反向映射
// let nameOfA = Enum["0"]; //正确
// console.log(nameOfA); //fall

// // console.log(a);
// let a1: 0 | 1;
// interface A {
//   a: Typ.Red;
// }

// let aa: A = {
//   a: Typ.Red,
// };

// 因为必定抛出异常，所以 error 将不会有返回值
function error(message: string): never {
  throw new Error(message);
}

// error("kkkk");

interface A {
  type: "foo";
}

interface B {
  type: "bar";
}
interface C {
  type: "bizz";
}
type All = A | B;
function handleValue(val: All) {
  switch (val.type) {
    case "foo":
      break;
    case "bar":
      break;
    default:
      //兜底逻辑 ⼀般是不会进⼊这⼉如果进来了就是程序异常了
      const exhaustiveCheck: never = val;
      break;
  }
}

//void类型只是没有返回值 但本身不会出错
function Void(): void {
  console.log();
}

//只会抛出异常没有返回值
function Never(): never {
  throw new Error("aaa");
}
